1. Field of the Invention
The present invention relates generally to the field of computers, and more particularly, to a system and method permitting nodes coupled to a memory multiprocessor bus to share "piggyback" read responses.
2. Related Art
Modern multiprocessing systems typically have a plurality of processors, a main memory and other input/output (I/O) devices that are coupled to a main system bus. To permit maximum utilization of the bus these systems use split transactions. (For simplification, the processors, main memory and I/O devices will be referred to as "nodes".) A split transaction is a read transaction that is split into a read request transaction that contains the address of the data requested, and a reply transaction that contains the requested data. Reply transactions are also called read responses. Each transaction must be tagged so that the requesting node and the replying node (e.g., main memory or a processor having the requested data in its cache) can keep track of the status of the read request. When individual transactions being performed by a node are long in duration, a split transaction approach allows several transactions to simultaneously occupy the bus, thus increasing the effective bandwidth of the bus.
In order to support split transactions on a shared bus, both the requesting node and the replying node must arbitrate for the bus to perform their respective functions. Thus a split transaction bus has higher bandwidth, but usually has higher latency than a bus that is held for the entire read transaction.
Several modern multiprocessing systems employ split transactions. A conventional bus system called FutureBus also describes a mechanism called "snarfing", which allows multiple nodes to participate in a read response transaction. What these systems lack is a technique for efficiently tracking split reads, maintaining cache coherency while split transactions are pending, and allowing multiple nodes to accept read responses without impacting bus bandwidth or latency. For example, while FutureBus describes the snarfing mechanism, it does not present a method for snarfing split transactions explicitly. Instead, FutureBus suggests that when multiple nodes attempt to initiate split transactions to the same cache line, all nodes but the first node issuing the request should be told to wait or retry later, which is an inefficient use of bus bandwidth. Also missing from FutureBus is a mechanism which tells nodes that a given read response for a split transaction targets the same address they are attempting to read, which must be known for snarfing to occur.
What is desired is a system and method for sharing read responses on a split transaction multiprocessor bus, while eliminating redundant read requests.